home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / lxml / cssselect.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  26.6 KB  |  947 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import re
  5. from lxml import etree
  6. __all__ = [
  7.     'SelectorSyntaxError',
  8.     'ExpressionError',
  9.     'CSSSelector']
  10.  
  11. try:
  12.     _basestring = basestring
  13. except NameError:
  14.     _basestring = str
  15.  
  16.  
  17. class SelectorSyntaxError(SyntaxError):
  18.     pass
  19.  
  20.  
  21. class ExpressionError(RuntimeError):
  22.     pass
  23.  
  24.  
  25. class CSSSelector(etree.XPath):
  26.     
  27.     def __init__(self, css):
  28.         path = css_to_xpath(css)
  29.         etree.XPath.__init__(self, path)
  30.         self.css = css
  31.  
  32.     
  33.     def __repr__(self):
  34.         return '<%s %s for %r>' % (self.__class__.__name__, hex(abs(id(self)))[2:], self.css)
  35.  
  36.  
  37.  
  38. try:
  39.     _unicode = unicode
  40. except NameError:
  41.     _unicode = str
  42.  
  43.  
  44. class _UniToken(_unicode):
  45.     
  46.     def __new__(cls, contents, pos):
  47.         obj = _unicode.__new__(cls, contents)
  48.         obj.pos = pos
  49.         return obj
  50.  
  51.     
  52.     def __repr__(self):
  53.         return '%s(%s, %r)' % (self.__class__.__name__, _unicode.__repr__(self), self.pos)
  54.  
  55.  
  56.  
  57. class Symbol(_UniToken):
  58.     pass
  59.  
  60.  
  61. class String(_UniToken):
  62.     pass
  63.  
  64.  
  65. class Token(_UniToken):
  66.     pass
  67.  
  68.  
  69. class Class(object):
  70.     
  71.     def __init__(self, selector, class_name):
  72.         self.selector = selector
  73.         self.class_name = class_name
  74.  
  75.     
  76.     def __repr__(self):
  77.         return '%s[%r.%s]' % (self.__class__.__name__, self.selector, self.class_name)
  78.  
  79.     
  80.     def xpath(self):
  81.         sel_xpath = self.selector.xpath()
  82.         sel_xpath.add_condition("contains(concat(' ', normalize-space(@class), ' '), %s)" % xpath_repr(' ' + self.class_name + ' '))
  83.         return sel_xpath
  84.  
  85.  
  86.  
  87. class Function(object):
  88.     unsupported = [
  89.         'target',
  90.         'lang',
  91.         'enabled',
  92.         'disabled']
  93.     
  94.     def __init__(self, selector, type, name, expr):
  95.         self.selector = selector
  96.         self.type = type
  97.         self.name = name
  98.         self.expr = expr
  99.  
  100.     
  101.     def __repr__(self):
  102.         return '%s[%r%s%s(%r)]' % (self.__class__.__name__, self.selector, self.type, self.name, self.expr)
  103.  
  104.     
  105.     def xpath(self):
  106.         sel_path = self.selector.xpath()
  107.         if self.name in self.unsupported:
  108.             raise ExpressionError('The psuedo-class %r is not supported' % self.name)
  109.         
  110.         method = '_xpath_' + self.name.replace('-', '_')
  111.         if not hasattr(self, method):
  112.             raise ExpressionError('The psuedo-class %r is unknown' % self.name)
  113.         
  114.         method = getattr(self, method)
  115.         return method(sel_path, self.expr)
  116.  
  117.     
  118.     def _xpath_nth_child(self, xpath, expr, last = False, add_name_test = True):
  119.         (a, b) = parse_series(expr)
  120.         if not a and not b and not last:
  121.             xpath.add_condition('false() and position() = 0')
  122.             return xpath
  123.         
  124.         if add_name_test:
  125.             xpath.add_name_test()
  126.         
  127.         xpath.add_star_prefix()
  128.         if a == 0:
  129.             if last:
  130.                 b = 'last() - %s' % b
  131.             
  132.             xpath.add_condition('position() = %s' % b)
  133.             return xpath
  134.         
  135.         if last:
  136.             a = -a
  137.             b = -b
  138.         
  139.         if b > 0:
  140.             b_neg = str(-b)
  141.         else:
  142.             b_neg = '+%s' % -b
  143.         if a != 1:
  144.             expr = [
  145.                 '(position() %s) mod %s = 0' % (b_neg, a)]
  146.         else:
  147.             expr = []
  148.         if b >= 0:
  149.             expr.append('position() >= %s' % b)
  150.         elif b < 0 and last:
  151.             expr.append('position() < (last() %s)' % b)
  152.         
  153.         expr = ' and '.join(expr)
  154.         if expr:
  155.             xpath.add_condition(expr)
  156.         
  157.         return xpath
  158.  
  159.     
  160.     def _xpath_nth_last_child(self, xpath, expr):
  161.         return self._xpath_nth_child(xpath, expr, last = True)
  162.  
  163.     
  164.     def _xpath_nth_of_type(self, xpath, expr):
  165.         if xpath.element == '*':
  166.             raise NotImplementedError('*:nth-of-type() is not implemented')
  167.         
  168.         return self._xpath_nth_child(xpath, expr, add_name_test = False)
  169.  
  170.     
  171.     def _xpath_nth_last_of_type(self, xpath, expr):
  172.         return self._xpath_nth_child(xpath, expr, last = True, add_name_test = False)
  173.  
  174.     
  175.     def _xpath_contains(self, xpath, expr):
  176.         if isinstance(expr, Element):
  177.             expr = expr._format_element()
  178.         
  179.         xpath.add_condition('contains(css:lower-case(string(.)), %s)' % xpath_repr(expr.lower()))
  180.         return xpath
  181.  
  182.     
  183.     def _xpath_not(self, xpath, expr):
  184.         expr = expr.xpath()
  185.         cond = expr.condition
  186.         xpath.add_condition('not(%s)' % cond)
  187.         return xpath
  188.  
  189.  
  190.  
  191. def _make_lower_case(context, s):
  192.     return s.lower()
  193.  
  194. ns = etree.FunctionNamespace('http://codespeak.net/lxml/css/')
  195. ns.prefix = 'css'
  196. ns['lower-case'] = _make_lower_case
  197.  
  198. class Pseudo(object):
  199.     unsupported = [
  200.         'indeterminate',
  201.         'first-line',
  202.         'first-letter',
  203.         'selection',
  204.         'before',
  205.         'after',
  206.         'link',
  207.         'visited',
  208.         'active',
  209.         'focus',
  210.         'hover']
  211.     
  212.     def __init__(self, element, type, ident):
  213.         self.element = element
  214.         self.type = type
  215.         self.ident = ident
  216.  
  217.     
  218.     def __repr__(self):
  219.         return '%s[%r%s%s]' % (self.__class__.__name__, self.element, self.type, self.ident)
  220.  
  221.     
  222.     def xpath(self):
  223.         el_xpath = self.element.xpath()
  224.         if self.ident in self.unsupported:
  225.             raise ExpressionError('The psuedo-class %r is unsupported' % self.ident)
  226.         
  227.         method = '_xpath_' + self.ident.replace('-', '_')
  228.         if not hasattr(self, method):
  229.             raise ExpressionError('The psuedo-class %r is unknown' % self.ident)
  230.         
  231.         method = getattr(self, method)
  232.         el_xpath = method(el_xpath)
  233.         return el_xpath
  234.  
  235.     
  236.     def _xpath_checked(self, xpath):
  237.         xpath.add_condition("(@selected or @checked) and (name(.) = 'input' or name(.) = 'option')")
  238.         return xpath
  239.  
  240.     
  241.     def _xpath_root(self, xpath):
  242.         raise NotImplementedError
  243.  
  244.     
  245.     def _xpath_first_child(self, xpath):
  246.         xpath.add_star_prefix()
  247.         xpath.add_name_test()
  248.         xpath.add_condition('position() = 1')
  249.         return xpath
  250.  
  251.     
  252.     def _xpath_last_child(self, xpath):
  253.         xpath.add_star_prefix()
  254.         xpath.add_name_test()
  255.         xpath.add_condition('position() = last()')
  256.         return xpath
  257.  
  258.     
  259.     def _xpath_first_of_type(self, xpath):
  260.         if xpath.element == '*':
  261.             raise NotImplementedError('*:first-of-type is not implemented')
  262.         
  263.         xpath.add_star_prefix()
  264.         xpath.add_condition('position() = 1')
  265.         return xpath
  266.  
  267.     
  268.     def _xpath_last_of_type(self, xpath):
  269.         if xpath.element == '*':
  270.             raise NotImplementedError('*:last-of-type is not implemented')
  271.         
  272.         xpath.add_star_prefix()
  273.         xpath.add_condition('position() = last()')
  274.         return xpath
  275.  
  276.     
  277.     def _xpath_only_child(self, xpath):
  278.         xpath.add_name_test()
  279.         xpath.add_star_prefix()
  280.         xpath.add_condition('last() = 1')
  281.         return xpath
  282.  
  283.     
  284.     def _xpath_only_of_type(self, xpath):
  285.         if xpath.element == '*':
  286.             raise NotImplementedError('*:only-of-type is not implemented')
  287.         
  288.         xpath.add_condition('last() = 1')
  289.         return xpath
  290.  
  291.     
  292.     def _xpath_empty(self, xpath):
  293.         xpath.add_condition('not(*) and not(normalize-space())')
  294.         return xpath
  295.  
  296.  
  297.  
  298. class Attrib(object):
  299.     
  300.     def __init__(self, selector, namespace, attrib, operator, value):
  301.         self.selector = selector
  302.         self.namespace = namespace
  303.         self.attrib = attrib
  304.         self.operator = operator
  305.         self.value = value
  306.  
  307.     
  308.     def __repr__(self):
  309.         if self.operator == 'exists':
  310.             return '%s[%r[%s]]' % (self.__class__.__name__, self.selector, self._format_attrib())
  311.         else:
  312.             return '%s[%r[%s %s %r]]' % (self.__class__.__name__, self.selector, self._format_attrib(), self.operator, self.value)
  313.  
  314.     
  315.     def _format_attrib(self):
  316.         if self.namespace == '*':
  317.             return self.attrib
  318.         else:
  319.             return '%s|%s' % (self.namespace, self.attrib)
  320.  
  321.     
  322.     def _xpath_attrib(self):
  323.         if self.namespace == '*':
  324.             return '@' + self.attrib
  325.         else:
  326.             return '@%s:%s' % (self.namespace, self.attrib)
  327.  
  328.     
  329.     def xpath(self):
  330.         path = self.selector.xpath()
  331.         attrib = self._xpath_attrib()
  332.         value = self.value
  333.         if self.operator == 'exists':
  334.             path.add_condition(attrib)
  335.         elif self.operator == '=':
  336.             path.add_condition('%s = %s' % (attrib, xpath_repr(value)))
  337.         elif self.operator == '!=':
  338.             if value:
  339.                 path.add_condition('not(%s) or %s != %s' % (attrib, attrib, xpath_repr(value)))
  340.             else:
  341.                 path.add_condition('%s != %s' % (attrib, xpath_repr(value)))
  342.         elif self.operator == '~=':
  343.             path.add_condition("contains(concat(' ', normalize-space(%s), ' '), %s)" % (attrib, xpath_repr(' ' + value + ' ')))
  344.         elif self.operator == '|=':
  345.             path.add_condition('%s = %s or starts-with(%s, %s)' % (attrib, xpath_repr(value), attrib, xpath_repr(value + '-')))
  346.         elif self.operator == '^=':
  347.             path.add_condition('starts-with(%s, %s)' % (attrib, xpath_repr(value)))
  348.         elif self.operator == '$=':
  349.             path.add_condition('substring(%s, string-length(%s)-%s) = %s' % (attrib, attrib, len(value) - 1, xpath_repr(value)))
  350.         elif self.operator == '*=':
  351.             path.add_condition('contains(%s, %s)' % (attrib, xpath_repr(value)))
  352.         
  353.         return path
  354.  
  355.  
  356.  
  357. class Element(object):
  358.     
  359.     def __init__(self, namespace, element):
  360.         self.namespace = namespace
  361.         self.element = element
  362.  
  363.     
  364.     def __repr__(self):
  365.         return '%s[%s]' % (self.__class__.__name__, self._format_element())
  366.  
  367.     
  368.     def _format_element(self):
  369.         if self.namespace == '*':
  370.             return self.element
  371.         else:
  372.             return '%s|%s' % (self.namespace, self.element)
  373.  
  374.     
  375.     def xpath(self):
  376.         if self.namespace == '*':
  377.             el = self.element.lower()
  378.         else:
  379.             el = '%s:%s' % (self.namespace, self.element)
  380.         return XPathExpr(element = el)
  381.  
  382.  
  383.  
  384. class Hash(object):
  385.     
  386.     def __init__(self, selector, id):
  387.         self.selector = selector
  388.         self.id = id
  389.  
  390.     
  391.     def __repr__(self):
  392.         return '%s[%r#%s]' % (self.__class__.__name__, self.selector, self.id)
  393.  
  394.     
  395.     def xpath(self):
  396.         path = self.selector.xpath()
  397.         path.add_condition('@id = %s' % xpath_repr(self.id))
  398.         return path
  399.  
  400.  
  401.  
  402. class Or(object):
  403.     
  404.     def __init__(self, items):
  405.         self.items = items
  406.  
  407.     
  408.     def __repr__(self):
  409.         return '%s(%r)' % (self.__class__.__name__, self.items)
  410.  
  411.     
  412.     def xpath(self):
  413.         paths = [ item.xpath() for item in self.items ]
  414.         return XPathExprOr(paths)
  415.  
  416.  
  417.  
  418. class CombinedSelector(object):
  419.     _method_mapping = {
  420.         ' ': 'descendant',
  421.         '>': 'child',
  422.         '+': 'direct_adjacent',
  423.         '~': 'indirect_adjacent' }
  424.     
  425.     def __init__(self, selector, combinator, subselector):
  426.         self.selector = selector
  427.         self.combinator = combinator
  428.         self.subselector = subselector
  429.  
  430.     
  431.     def __repr__(self):
  432.         if self.combinator == ' ':
  433.             comb = '<followed>'
  434.         else:
  435.             comb = self.combinator
  436.         return '%s[%r %s %r]' % (self.__class__.__name__, self.selector, comb, self.subselector)
  437.  
  438.     
  439.     def xpath(self):
  440.         if self.combinator not in self._method_mapping:
  441.             raise ExpressionError('Unknown combinator: %r' % self.combinator)
  442.         
  443.         method = '_xpath_' + self._method_mapping[self.combinator]
  444.         method = getattr(self, method)
  445.         path = self.selector.xpath()
  446.         return method(path, self.subselector)
  447.  
  448.     
  449.     def _xpath_descendant(self, xpath, sub):
  450.         xpath.join('/descendant::', sub.xpath())
  451.         return xpath
  452.  
  453.     
  454.     def _xpath_child(self, xpath, sub):
  455.         xpath.join('/', sub.xpath())
  456.         return xpath
  457.  
  458.     
  459.     def _xpath_direct_adjacent(self, xpath, sub):
  460.         xpath.join('/following-sibling::', sub.xpath())
  461.         xpath.add_name_test()
  462.         xpath.add_condition('position() = 1')
  463.         return xpath
  464.  
  465.     
  466.     def _xpath_indirect_adjacent(self, xpath, sub):
  467.         xpath.join('/following-sibling::', sub.xpath())
  468.         return xpath
  469.  
  470.  
  471. _el_re = re.compile('^\\w+\\s*$')
  472. _id_re = re.compile('^(\\w*)#(\\w+)\\s*$')
  473. _class_re = re.compile('^(\\w*)\\.(\\w+)\\s*$')
  474.  
  475. def css_to_xpath(css_expr, prefix = 'descendant-or-self::'):
  476.     if isinstance(css_expr, _basestring):
  477.         match = _el_re.search(css_expr)
  478.         if match is not None:
  479.             return '%s%s' % (prefix, match.group(0).strip())
  480.         
  481.         match = _id_re.search(css_expr)
  482.         if match is not None:
  483.             if not match.group(1):
  484.                 pass
  485.             return "%s%s[@id = '%s']" % (prefix, '*', match.group(2))
  486.         
  487.         match = _class_re.search(css_expr)
  488.         if match is not None:
  489.             if not match.group(1):
  490.                 pass
  491.             return "%s%s[contains(concat(' ', normalize-space(@class), ' '), ' %s ')]" % (prefix, '*', match.group(2))
  492.         
  493.         css_expr = parse(css_expr)
  494.     
  495.     expr = css_expr.xpath()
  496.     if prefix:
  497.         expr.add_prefix(prefix)
  498.     
  499.     return str(expr)
  500.  
  501.  
  502. class XPathExpr(object):
  503.     
  504.     def __init__(self, prefix = None, path = None, element = '*', condition = None, star_prefix = False):
  505.         self.prefix = prefix
  506.         self.path = path
  507.         self.element = element
  508.         self.condition = condition
  509.         self.star_prefix = star_prefix
  510.  
  511.     
  512.     def __str__(self):
  513.         path = ''
  514.         if self.prefix is not None:
  515.             path += str(self.prefix)
  516.         
  517.         if self.path is not None:
  518.             path += str(self.path)
  519.         
  520.         path += str(self.element)
  521.         if self.condition:
  522.             path += '[%s]' % self.condition
  523.         
  524.         return path
  525.  
  526.     
  527.     def __repr__(self):
  528.         return '%s[%s]' % (self.__class__.__name__, self)
  529.  
  530.     
  531.     def add_condition(self, condition):
  532.         if self.condition:
  533.             self.condition = '%s and (%s)' % (self.condition, condition)
  534.         else:
  535.             self.condition = condition
  536.  
  537.     
  538.     def add_path(self, part):
  539.         self.element = part
  540.  
  541.     
  542.     def add_prefix(self, prefix):
  543.         if self.prefix:
  544.             self.prefix = prefix + self.prefix
  545.         else:
  546.             self.prefix = prefix
  547.  
  548.     
  549.     def add_name_test(self):
  550.         if self.element == '*':
  551.             return None
  552.         
  553.         self.add_condition('name() = %s' % xpath_repr(self.element))
  554.         self.element = '*'
  555.  
  556.     
  557.     def add_star_prefix(self):
  558.         if self.path:
  559.             self.path += '*/'
  560.         else:
  561.             self.path = '*/'
  562.         self.star_prefix = True
  563.  
  564.     
  565.     def join(self, combiner, other):
  566.         prefix = str(self)
  567.         prefix += combiner
  568.         if not other.prefix:
  569.             pass
  570.         if not other.path:
  571.             pass
  572.         path = '' + ''
  573.         if other.star_prefix and path == '*/':
  574.             path = ''
  575.         
  576.         self.prefix = prefix
  577.         self.path = path
  578.         self.element = other.element
  579.         self.condition = other.condition
  580.  
  581.  
  582.  
  583. class XPathExprOr(XPathExpr):
  584.     
  585.     def __init__(self, items, prefix = None):
  586.         for item in items:
  587.             pass
  588.         
  589.         self.items = items
  590.         self.prefix = prefix
  591.  
  592.     
  593.     def __str__(self):
  594.         if not self.prefix:
  595.             pass
  596.         prefix = ''
  597.         return []([ prefix + str(i) for i in self.items ])
  598.  
  599.  
  600.  
  601. def xpath_repr(s):
  602.     if isinstance(s, Element):
  603.         s = s._format_element()
  604.     
  605.     return repr(str(s))
  606.  
  607.  
  608. def parse(string):
  609.     stream = TokenStream(tokenize(string))
  610.     stream.source = string
  611.     
  612.     try:
  613.         return parse_selector_group(stream)
  614.     except SelectorSyntaxError:
  615.         e = sys.exc_info()[1]
  616.         e.args = tuple([
  617.             '%s at %s -> %s' % (e, stream.used, list(stream))])
  618.         raise 
  619.  
  620.  
  621.  
  622. def parse_selector_group(stream):
  623.     result = []
  624.     while None:
  625.         if stream.peek() == ',':
  626.             stream.next()
  627.             continue
  628.         break
  629.         continue
  630.         if len(result) == 1:
  631.             return result[0]
  632.         else:
  633.             return Or(result)
  634.  
  635.  
  636. def parse_selector(stream):
  637.     result = parse_simple_selector(stream)
  638.     while None:
  639.         peek = stream.peek()
  640.         if peek == ',' or peek is None:
  641.             return result
  642.         elif peek in ('+', '>', '~'):
  643.             combinator = stream.next()
  644.         else:
  645.             combinator = ' '
  646.         next_selector = parse_simple_selector(stream)
  647.         result = CombinedSelector(result, combinator, next_selector)
  648.         continue
  649.         return result
  650.  
  651.  
  652. def parse_simple_selector(stream):
  653.     peek = stream.peek()
  654.     if peek != '*' and not isinstance(peek, Symbol):
  655.         element = namespace = '*'
  656.     else:
  657.         next = stream.next()
  658.         if next != '*' and not isinstance(next, Symbol):
  659.             raise SelectorSyntaxError('Expected symbol, got %r' % next)
  660.         
  661.         if stream.peek() == '|':
  662.             namespace = next
  663.             stream.next()
  664.             element = stream.next()
  665.             if element != '*' and not isinstance(next, Symbol):
  666.                 raise SelectorSyntaxError('Expected symbol, got %r' % next)
  667.             
  668.         else:
  669.             namespace = '*'
  670.             element = next
  671.     result = Element(namespace, element)
  672.     has_hash = False
  673.     while None:
  674.         peek = stream.peek()
  675.         if peek == '#':
  676.             if has_hash:
  677.                 break
  678.             
  679.             stream.next()
  680.             result = Hash(result, stream.next())
  681.             has_hash = True
  682.             continue
  683.             continue
  684.         if peek == '.':
  685.             stream.next()
  686.             result = Class(result, stream.next())
  687.             continue
  688.             continue
  689.         if peek == '[':
  690.             stream.next()
  691.             result = parse_attrib(result, stream)
  692.             next = stream.next()
  693.             if not next == ']':
  694.                 raise SelectorSyntaxError('] expected, got %r' % next)
  695.                 continue
  696.             continue
  697.             continue
  698.         if peek == ':' or peek == '::':
  699.             type = stream.next()
  700.             ident = stream.next()
  701.             if not isinstance(ident, Symbol):
  702.                 raise SelectorSyntaxError('Expected symbol, got %r' % ident)
  703.             
  704.             if stream.peek() == '(':
  705.                 stream.next()
  706.                 peek = stream.peek()
  707.                 if isinstance(peek, String):
  708.                     selector = stream.next()
  709.                 elif isinstance(peek, Symbol) and is_int(peek):
  710.                     selector = int(stream.next())
  711.                 else:
  712.                     selector = parse_simple_selector(stream)
  713.                 next = stream.next()
  714.                 if not next == ')':
  715.                     raise SelectorSyntaxError('Expected ), got %r and %r' % (next, selector))
  716.                 
  717.                 result = Function(result, type, ident, selector)
  718.                 continue
  719.             result = Pseudo(result, type, ident)
  720.             continue
  721.             continue
  722.         if peek == ' ':
  723.             stream.next()
  724.         
  725.         break
  726.         continue
  727.         return result
  728.  
  729.  
  730. def is_int(v):
  731.     
  732.     try:
  733.         int(v)
  734.     except ValueError:
  735.         return False
  736.  
  737.     return True
  738.  
  739.  
  740. def parse_attrib(selector, stream):
  741.     attrib = stream.next()
  742.     if stream.peek() == '|':
  743.         namespace = attrib
  744.         stream.next()
  745.         attrib = stream.next()
  746.     else:
  747.         namespace = '*'
  748.     if stream.peek() == ']':
  749.         return Attrib(selector, namespace, attrib, 'exists', None)
  750.     
  751.     op = stream.next()
  752.     if op not in ('^=', '$=', '*=', '=', '~=', '|=', '!='):
  753.         raise SelectorSyntaxError('Operator expected, got %r' % op)
  754.     
  755.     value = stream.next()
  756.     if not isinstance(value, (Symbol, String)):
  757.         raise SelectorSyntaxError('Expected string or symbol, got %r' % value)
  758.     
  759.     return Attrib(selector, namespace, attrib, op, value)
  760.  
  761.  
  762. def parse_series(s):
  763.     if isinstance(s, Element):
  764.         s = s._format_element()
  765.     
  766.     if not s or s == '*':
  767.         return (0, 0)
  768.     
  769.     if isinstance(s, int):
  770.         return (0, s)
  771.     
  772.     if s == 'odd':
  773.         return (2, 1)
  774.     elif s == 'even':
  775.         return (2, 0)
  776.     elif s == 'n':
  777.         return (1, 0)
  778.     
  779.     if 'n' not in s:
  780.         return (0, int(s))
  781.     
  782.     (a, b) = s.split('n', 1)
  783.     if not a:
  784.         a = 1
  785.     elif a == '-' or a == '+':
  786.         a = int(a + '1')
  787.     else:
  788.         a = int(a)
  789.     if not b:
  790.         b = 0
  791.     elif b == '-' or b == '+':
  792.         b = int(b + '1')
  793.     else:
  794.         b = int(b)
  795.     return (a, b)
  796.  
  797. _whitespace_re = re.compile('\\s+')
  798. _comment_re = re.compile('/\\*.*?\\*/', re.S)
  799. _count_re = re.compile('[+-]?\\d*n(?:[+-]\\d+)?')
  800.  
  801. def tokenize(s):
  802.     pos = 0
  803.     s = _comment_re.sub('', s)
  804.     while None:
  805.         match = _whitespace_re.match(s, pos = pos)
  806.         if match:
  807.             preceding_whitespace_pos = pos
  808.             pos = match.end()
  809.         else:
  810.             preceding_whitespace_pos = 0
  811.         if pos >= len(s):
  812.             return None
  813.         
  814.         match = _count_re.match(s, pos = pos)
  815.         if match and match.group() != 'n':
  816.             sym = s[pos:match.end()]
  817.             yield Symbol(sym, pos)
  818.             pos = match.end()
  819.             continue
  820.         
  821.         c = s[pos]
  822.         c2 = s[pos:pos + 2]
  823.         if c2 in ('~=', '|=', '^=', '$=', '*=', '::', '!='):
  824.             yield Token(c2, pos)
  825.             pos += 2
  826.             continue
  827.         
  828.         if c in '>+~,.*=[]()|:#':
  829.             if c in '.#' and preceding_whitespace_pos > 0:
  830.                 yield Token(' ', preceding_whitespace_pos)
  831.             
  832.             yield Token(c, pos)
  833.             pos += 1
  834.             continue
  835.         
  836.         if c == '"' or c == "'":
  837.             old_pos = pos
  838.             (sym, pos) = tokenize_escaped_string(s, pos)
  839.             yield String(sym, old_pos)
  840.             continue
  841.         
  842.         old_pos = pos
  843.         (sym, pos) = tokenize_symbol(s, pos)
  844.         yield Symbol(sym, old_pos)
  845.         continue
  846.         continue
  847.         return None
  848.  
  849.  
  850. def tokenize_escaped_string(s, pos):
  851.     quote = s[pos]
  852.     pos = pos + 1
  853.     start = pos
  854.     while None:
  855.         next = s.find(quote, pos)
  856.         if next == -1:
  857.             raise SelectorSyntaxError('Expected closing %s for string in: %r' % (quote, s[start:]))
  858.         
  859.         result = s[start:next]
  860.         
  861.         try:
  862.             result = result.encode('ASCII', 'backslashreplace').decode('unicode_escape')
  863.         except UnicodeDecodeError:
  864.             pos = next + 1
  865.             continue
  866.  
  867.         return (result, next + 1)
  868.         continue
  869.         return None
  870.  
  871. _illegal_symbol = re.compile('[^\\w\\\\-]', re.UNICODE)
  872.  
  873. def tokenize_symbol(s, pos):
  874.     start = pos
  875.     match = _illegal_symbol.search(s, pos = pos)
  876.     if not match:
  877.         return (s[start:], len(s))
  878.     
  879.     if match.start() == pos:
  880.         pass
  881.     
  882.     if not match:
  883.         result = s[start:]
  884.         pos = len(s)
  885.     else:
  886.         result = s[start:match.start()]
  887.         pos = match.start()
  888.     
  889.     try:
  890.         result = result.encode('ASCII', 'backslashreplace').decode('unicode_escape')
  891.     except UnicodeDecodeError:
  892.         e = sys.exc_info()[1]
  893.         raise SelectorSyntaxError('Bad symbol %r: %s' % (result, e))
  894.  
  895.     return (result, pos)
  896.  
  897.  
  898. class TokenStream(object):
  899.     
  900.     def __init__(self, tokens, source = None):
  901.         self.used = []
  902.         self.tokens = iter(tokens)
  903.         self.source = source
  904.         self.peeked = None
  905.         self._peeking = False
  906.         
  907.         try:
  908.             self.next_token = self.tokens.next
  909.         except AttributeError:
  910.             self.next_token = self.tokens.__next__
  911.  
  912.  
  913.     
  914.     def next(self):
  915.         if self._peeking:
  916.             self._peeking = False
  917.             self.used.append(self.peeked)
  918.             return self.peeked
  919.         else:
  920.             
  921.             try:
  922.                 next = self.next_token()
  923.                 self.used.append(next)
  924.                 return next
  925.             except StopIteration:
  926.                 return None
  927.  
  928.  
  929.     
  930.     def __iter__(self):
  931.         return iter(self.next, None)
  932.  
  933.     
  934.     def peek(self):
  935.         if not self._peeking:
  936.             
  937.             try:
  938.                 self.peeked = self.next_token()
  939.             except StopIteration:
  940.                 return None
  941.  
  942.             self._peeking = True
  943.         
  944.         return self.peeked
  945.  
  946.  
  947.